home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / v7n14.arc / PATHSUB.C < prev    next >
Encoding:
C/C++ Source or Header  |  1988-08-06  |  11.9 KB  |  342 lines
  1. /*- PATHSUB - Substitute strings in environment variables (default: PATH) 
  2.  
  3.      Usage: PATHSUB [/var] pat sub 
  4.  
  5.      PATHSUB will substitute the 1st occurrance of 'pat' in the environment 
  6.      variable 'var' with the replacement string 'sub'.  Both 'pat' and 'sub' 
  7.      are required.  The default environment variable is "PATH". 
  8.  
  9.      If 'var' is specified, it is converted to uppercase.  Both 'pat' and 
  10.      'sub' are case sensitive. 
  11.  
  12.      There are two special values for the parameter 'pat'.  If 'pat' is "^" 
  13.      then 'sub' will be placed at the head of the environment variable (after 
  14.      the '=' seperating the variable name from the value).  If 'pat' is "$" 
  15.      then 'sub' will be placed at the end of the environment.  Note that 
  16.      this is not full regular expression matching.  The pattern "^C:\BIN" 
  17.      will NOT attempt to find "C:\BIN" at the head of the path, but will 
  18.      search for "^C:\BIN" anywhere in the path. 
  19.  
  20.      If you wish to delete something from the path, overspecify the pattern 
  21.      and make the replacement match the extra e.g.: 
  22.  
  23.           PATHSUB ;C:\UTILS; ; 
  24.  
  25.      Exit codes: 
  26.           4 - Program could not run, not enough parameters 
  27.           3 - Program could not locate environment variable 
  28.           2 - Pattern not found in environment variable 
  29.           1 - Program could not update environment, substitution too big 
  30.           0 - Success 
  31.  
  32. */ 
  33.  
  34. #include <stdio.h> 
  35. #include <stdlib.h> 
  36. #include <process.h> 
  37. #include <memory.h> 
  38. #include <ctype.h> 
  39. #include <dos.h> 
  40. #include <string.h> 
  41.  
  42. #ifndef TRUE 
  43. #define TRUE 1 
  44. #endif 
  45.  
  46. #ifndef FALSE 
  47. #define FALSE 0 
  48. #endif 
  49.  
  50. #ifndef NULL 
  51. #define NULL 0 
  52. #endif 
  53.  
  54. #define Lastchar(string) string[strlen(string)-1] 
  55.  
  56. #define DEBUG       TRUE 
  57. #define VERBOSE     TRUE 
  58.  
  59. #define ENV_OFF 0x2C          /* environment segment */ 
  60. #define PPSP_OFF 0x16         /* parent PSP */ 
  61.      /* PSP of copy of COMMAND.COM that invoked current process */ 
  62. #define RPSP_OFF 0x10 
  63.  
  64. /* Maximum memory block we will try to deal with is 255 Paragraphs long */ 
  65. #define MAXLEN 0xFF0 
  66.  
  67. extern unsigned _psp;         /* from MSC: PSP segment for this task */ 
  68.  
  69. unsigned _rpsp;               /* "root" PSP segment */ 
  70. unsigned _cpsp;               /* current PSP segment */ 
  71. unsigned _env_seg;            /* environment segment */ 
  72. unsigned _ctrl_seg;           /* memory control block segment */ 
  73. unsigned _mem_seg;            /* memory block segment */ 
  74.  
  75. struct _ctrl_block 
  76. { 
  77.      char type;          /* 'M' more memory follows, 'Z' zero more blocks */ 
  78.      unsigned owner;     /* PSP of task which owns this memory */ 
  79.      unsigned length;    /* # of segments in this block of memory */ 
  80. } ctrl_block; 
  81.  
  82. unsigned char mem_block[MAXLEN]; 
  83.  
  84. main(argc, argv) 
  85. int argc; 
  86. char *argv[]; 
  87. { 
  88.      unsigned _showds(); 
  89.  
  90.      static char cmdpath[256]; 
  91.      static char path[256]; 
  92.      static char target[100] = { "PATH=" }; 
  93.      char *comspec,*pos; 
  94.      int i, done; 
  95.      int ppos, off; 
  96.      unsigned ds; 
  97.      int firstarg; 
  98.  
  99.      firstarg=1; 
  100.  
  101.      /* if alternate environment var specified */ 
  102.      if (argv[firstarg][0] == '/') 
  103.      { 
  104.           strcpy(target, argv[firstarg++]+1); /* copy from arg (after '/') */ 
  105.           strcat(target, "=");                /* append an '=' */ 
  106.           strupr(target);                     /* convert to uppercase */ 
  107.      } 
  108.  
  109.      if (argc < firstarg+2) 
  110.      { 
  111.           fprintf(stderr, "\nPATHSUB: Usage - PATHSUB [/var] pat sub"); 
  112.           exit(4); 
  113.      } 
  114.  
  115.      ds = _showds();               /* get our data segment */ 
  116.      _rpsp = _psp;                 /* start w/ our own PSP segment */ 
  117.      _cpsp = _rpsp ^ 0xFFFF;       /* Dummy value to start with */ 
  118.  
  119.      while (_cpsp != _rpsp)        /* while haven't found PSP of 1st COMMAND */ 
  120.      { 
  121.           _cpsp = _rpsp;           /* up another layer */ 
  122.                                    /* get "root" PSP segment */ 
  123.           movedata(_cpsp, RPSP_OFF, ds, (unsigned)&_rpsp, 2); 
  124.      } 
  125.  
  126.           /* get the memory control block from the root PSP */ 
  127.      _mem_seg = _cpsp;             /* start with the PSP segment */ 
  128.      _ctrl_seg = _cpsp - 1;        /* and back up by one segment */ 
  129.  
  130.           /* copy it to where we can use it */ 
  131.      movedata(_ctrl_seg, 0, ds, (unsigned)&ctrl_block, sizeof(ctrl_block)); 
  132.  
  133.      done = FALSE; 
  134.      ppos = -1; 
  135.      while (!done) 
  136.      { 
  137.                /* find next control block */ 
  138.           _ctrl_seg = _mem_seg + ctrl_block.length; 
  139.                /* & next block of memory */ 
  140.           _mem_seg = _ctrl_seg + 1; 
  141.                /* load control block */ 
  142.           movedata(_ctrl_seg, 0, ds, (unsigned)&ctrl_block.type, 5); 
  143.  
  144.           done = (ctrl_block.type != 'M'); 
  145.           if(!done) 
  146.                     /* examine mem block, if not too big */ 
  147.           if(ctrl_block.length < MAXLEN) 
  148.              { 
  149.                      /* Load the block */ 
  150.                movedata(_mem_seg, 0, ds, (unsigned)mem_block, 
  151.                               ctrl_block.length*16); 
  152.  
  153.                     /* find the first occurance of our pattern in the block */ 
  154.                     /* if it does not appear, result will be -1 */ 
  155.  
  156.                     /* search the block      */ 
  157.                     for(ppos = off = 0;  !done && off != -1; ppos++) 
  158.                     { 
  159.                          /* if found */ 
  160.                          if( (off = memsrch(&mem_block[ppos], target, 
  161.                               (ctrl_block.length*16)-off )) != -1) 
  162.                          { 
  163.                               ppos+=off; 
  164.                                                        /* and if valid */ 
  165.                               if(ppos == 0 || mem_block[ppos-1] == NULL) 
  166.                               { 
  167.                                    done = TRUE;   /* set to break main loop */ 
  168.                                    break;         /* get out of for loop */ 
  169.                               } 
  170.                          } 
  171.                     } 
  172.                } /* end: look through this memory block */ 
  173.      } /* end: look through all memory blocks */ 
  174.  
  175.      if((ppos == -1) || (ctrl_block.type != 'M')) 
  176.      { 
  177.           Lastchar(target); 
  178.           fprintf(stderr, 
  179.                "\nPATHSUB: Could not locate environment variable [%s].", 
  180.                 target); 
  181.           exit(3); 
  182.      } 
  183.  
  184.      strcpy(path, &mem_block[ppos]);    /* copy our current "PATH=" string */ 
  185.  
  186.      if(!strcmp(argv[firstarg],"^"))              /* Insert at head of path */ 
  187.           sprintf(cmdpath,"%s%s%s", target, argv[firstarg+1], 
  188.                     path+strlen(target)); 
  189.      else if (!strcmp(argv[firstarg], "$"))  /* Append to tail of path */ 
  190.           sprintf(cmdpath, "%s%s",path,argv[firstarg+1]); 
  191.      else                                         /* Substitute into path */ 
  192.      { 
  193.           strcpy(cmdpath,path); 
  194.           i = strsub(cmdpath+strlen(target), argv[firstarg], 
  195.                          argv[firstarg+1], 1); 
  196.           if(i == 0) 
  197.           { 
  198.                target[strlen(target)-1] = NULL; 
  199.                fprintf(stderr, 
  200.           "PATHSUB: pattern [%s] not found in environment variable [%s].\n", 
  201.                argv[firstarg], target); 
  202.                exit(2); 
  203.           } 
  204.      } 
  205.  
  206.           /* Remove old entry FROM OUR COPY of environment block */ 
  207.      delete(mem_block, ppos); 
  208.  
  209.      /* Make new entry in OUR COPY of environment block.  If the addition */ 
  210.      /* fits, THEN copy entire block back where it came from */ 
  211.      if(append(mem_block, cmdpath, ctrl_block.length*16)) 
  212.      { 
  213.           movedata(ds, (unsigned)mem_block, _mem_seg, 0, ctrl_block.length*16); 
  214.           exit(0); 
  215.      } 
  216.  
  217.           /* if it did not get successfully added, just leave */ 
  218.      fprintf(stderr, 
  219.           "PATHSUB: Not enough environment space -- environment unchanged\n"); 
  220.      exit(1); 
  221. } 
  222.  
  223. /* ===================== String handling routines ========================= */ 
  224. /*  Purpose:  this routine will substitute up to "num" occurances of the     * 
  225. *            pattern "pat" in the string "s" with the replacement "sub".     * 
  226. *            the actual number of substitutions performed is returned.       * 
  227. *            if "num" is -1, then all occurances of "pat" are changed.       * 
  228. */ 
  229. int strsub(s, pat, sub, num) 
  230. char *s, *pat, *sub; 
  231. int num; 
  232. { 
  233.      int     idx, i, ii, count, off; 
  234.      char    news[161]; 
  235.  
  236.      for( count = off = 0; TRUE; count++) 
  237.      { 
  238.                /* we only need to check string past end of last substitution */ 
  239.           idx = stridx(&s[off], pat); 
  240.                /* if count is over the limit and limit specified, 
  241.                      or pattern not found */ 
  242.           if( ((count >= num) && (num != -1)) || (idx == -1)) 
  243.                return count+1; 
  244.  
  245.                /* idx + off is now the offset to the beginning of pat in s */ 
  246.                /* copy from up to pattern in string to local buffer */ 
  247.      for (i = off; i < idx+off; i++)  /* only need to cp from last chg */ 
  248.                news[i] = s[i]; 
  249.  
  250.                /* ad the substitution   */ 
  251.           for (ii = 0; ii < strlen(sub); ii++) 
  252.                news[i+ii] = sub[ii]; 
  253.  
  254.                 /* finish copying the rest of the string */ 
  255.           ii = idx+off + strlen(sub);             /* where src picks up */ 
  256.           i = idx+off + strlen(pat);              /* where need end on dest */ 
  257.           off = ii;                               /* remember for next cycle */ 
  258.           while(s[i]) 
  259.                news[ii++] = s[i++]; 
  260.           news[ii] = NULL; 
  261.           strcpy(s, news); 
  262.      } 
  263.      return count;  /* return number of subs done */ 
  264. } 
  265.  
  266.  
  267. int  stridx(s,p) 
  268. char *s,*p; 
  269. { 
  270.      char *p2; 
  271.  
  272.      if( p2 = strstr(s,p))                   /* if p found in s,      */ 
  273.           return p2-s;                       /* return offset into s  */ 
  274.      return -1;                              /* else return -1        */ 
  275. } 
  276.  
  277.  
  278. unsigned _showds() 
  279. { 
  280.      struct SREGS segregs; 
  281.  
  282.      segread(&segregs);                      /* read the segment registers */ 
  283.      return(segregs.ds);                     /* return DS */ 
  284. } 
  285.  
  286. int memsrch(mem,str,len) 
  287. char *mem, *str; 
  288. int len; 
  289. { 
  290.      int       i, j; 
  291.  
  292.      len -= strlen(str); 
  293.                                              /* for each character of mem */ 
  294.      for( j = 0; j <= len; j++) 
  295.      { 
  296.                                              /* compare the following chars */ 
  297.           for( i = 0 ; (mem[j+i] == str[i]) && str[i]; i++); 
  298.           if(!str[i])                        /* if at end of string */ 
  299.                return j;                     /* return the index */ 
  300.      } 
  301.      return -1; 
  302. } 
  303.  
  304. delete(block, index) 
  305. char *block; 
  306. int index; 
  307. { 
  308.      int size, end; 
  309.  
  310.           /* find end of environment (2nd of 2 NULLs in a row) */ 
  311.      for( end = 1; block[end-1] || block[end]; end++); 
  312.  
  313.           /* get length of entry being deleted */ 
  314.      size = strlen(&block[index])+1; 
  315.  
  316.           /* shift the remaining block down on top of string being deleted */ 
  317.      for(index += size; index <= end; index++) 
  318.           block[index-size] = block[index]; 
  319. } 
  320.  
  321. append(block, string, maxlen) 
  322. char *block, *string; 
  323. unsigned int maxlen; 
  324. { 
  325.      int end, size, i; 
  326.  
  327.                               /* find starting point for string to be added */ 
  328.      for( end = 1; block[end-1] || block[end]; end++); 
  329.  
  330.      size = strlen(string) + 2;    /* measure length of new string + 2 NULLs */ 
  331.  
  332.           /* check to see where last (proposed) byte falls in block */ 
  333.      if((end+size) > maxlen) 
  334.           return(FALSE); 
  335.                                    /* copy it -- we have enough room */ 
  336.      for( i = 0; string[i]; block[end++] = string[i++]); 
  337.      block[end++] = NULL; 
  338.      block[end++] = NULL; 
  339.  
  340.      return TRUE; 
  341. } 
  342.